import { _decorator, Label, Color } from "cc";
import { SpriteFrame } from "cc";
import { Sprite } from "cc";
import { JsonAsset } from "cc";
import { resources } from "cc";

const { ccclass } = _decorator;

/**
 * 语言配置接口
 * @interface LanguageConfig
 * @property {string} fallbackLocale - 默认语言代码
 * @property {Object} languages - 支持的语言配置
 */
export interface LanguageConfig {
  fallbackLocale: string;
  languages: {
    [key: string]: {
      [key: string]: {
        value: string;
        style?: {
          fontSize?: number;
          color?: string;
          alpha?: number;
          stroke?: number;
          strokeColor?: string;
          bold?: boolean;
          italic?: boolean;
        };
      };
    };
  };
}

/**
 * 本地化数据接口
 * @interface LocalizeData
 * @property {string} text - 文本内容
 * @property {Object} [style] - 文本样式（可选）
 */
export interface LocalizeData {
  text: string;
  style?: {
    fontSize?: number;
    color?: string;
    alpha?: number;
    stroke?: number;
    strokeColor?: string;
    bold?: boolean;
    italic?: boolean;
  };
}

/**
 * 本地化管理器
 * @class LocalizeManager
 * @description 用于管理游戏的多语言本地化功能，包括语言检测、切换和文本格式化
 */
@ccclass("LocalizeManager")
export class LocalizeManager {
  /** 默认语言 */
  private static _defaultLanguage: string = "en";
  /** 语言配置数据 */
  private static languages: { [key: string]: any } = {};
  /** 当前语言代码 */
  private static curLanguage: string = "";
  /** 当前语言名称 */
  private static curLanguageName: string = "";
  /** 文本样式缓存 */
  private static textStyle: { [key: string]: any } = {};

  /**
   * 获取默认语言
   * @returns {string} 默认语言代码
   */
  static get defaultLanguage(): string {
    return this._defaultLanguage;
  }

  /**
   * 获取当前语言名称
   * @returns {string} 当前语言名称
   */
  static get curLocalizeName(): string {
    return this.curLanguageName;
  }

  /**
   * 格式化文本
   * @param {string} format - 格式化字符串
   * @param {...any} params - 格式化参数
   * @returns {string} 格式化后的文本
   */
  static format(format: string, ...params: any[]): string {
    return format.replace(/{(\d+)}/g, (match, number) => {
      return typeof params[number] != "undefined" ? params[number] : match;
    });
  }

  /**
   * 初始化本地化系统
   * @param {LanguageConfig} config - 语言配置
   */
  static initialize(config: LanguageConfig): void {
    this.loadLanguageConfig(config);
    this.detectBrowserLanguage();
  }

  /**
   * 获取当前语言代码
   * @returns {string} 当前语言代码
   */
  static getCurrentLanguage(): string {
    return this.curLanguage;
  }

  /**
   * 从JSON资源解析语言配置
   * @param {JsonAsset} jsonAsset - JSON资源
   * @returns {LanguageConfig} 语言配置
   */
  static parseLanguageConfig(jsonAsset: JsonAsset): LanguageConfig {
    if (!jsonAsset || !jsonAsset.json) {
      console.error("Invalid JSON asset");
      return null;
    }

    try {
      const json = jsonAsset.json;
      const config: LanguageConfig = {
        fallbackLocale: json.fallbackLocale || "en",
        languages: {},
      };

      // 解析每种语言
      for (const langCode in json.languages) {
        if (json.languages.hasOwnProperty(langCode)) {
          const langData = json.languages[langCode];
          config.languages[langCode] = {};

          // 解析每种语言的文本数据
          for (const key in langData) {
            if (langData.hasOwnProperty(key)) {
              const value = langData[key];
              config.languages[langCode][key] = {
                value: value.value,
                style: value.style
                  ? {
                      fontSize: value.style.fontSize,
                      color: value.style.color,
                      alpha: value.style.alpha,
                      stroke: value.style.stroke,
                      strokeColor: value.style.strokeColor,
                      bold: value.style.bold,
                      italic: value.style.italic,
                    }
                  : undefined,
              };
            }
          }
        }
      }

      return config;
    } catch (error) {
      console.error("Failed to parse language config:", error);
      return null;
    }
  }

  /**
   * 加载语言配置
   * @param {LanguageConfig} languageConfig - 语言配置
   */
  static loadLanguageConfig(languageConfig: LanguageConfig): void {
    this._defaultLanguage = languageConfig.fallbackLocale;
    this.languages = languageConfig.languages;
  }

  /**
   * 获取当前语言的文本值
   * @param {string} key - 文本键值
   * @returns {LocalizeData} 本地化数据
   */
  static getCurLocalizeValue(key: string): LocalizeData {
    const languageData = this.languages[this.curLanguage];
    if (!languageData) return null;

    const data = languageData[key];
    if (!data) return null;

    return {
      text: data.value,
      style: data.style,
    };
  }

  /**
   * 更新文本样式
   * @param {Label} label - 文本标签组件
   * @param {string} key - 文本键值
   * @param {boolean} [updateText=true] - 是否更新文本内容
   */
  static updateStyle(
    label: Label,
    key: string,
    updateText: boolean = true
  ): void {
    const data = this.getCurLocalizeValue(key);
    if (!data) {
      console.log("找不到key值为" + key + "的数据")
      return
    }

    if (updateText) {
      label.string = data.text;
    }

    if (data.style) {
      if (data.style.fontSize) {
        label.fontSize = data.style.fontSize;
      }
      if (data.style.color) {
        label.color = new Color(data.style.color);
      }
      // if (data.style.alpha !== undefined) {
      //     label.opacity = data.style.alpha * 255;
      // }
      // if (data.style.stroke !== undefined) {
      //     label.stroke = data.style.stroke;
      // }
      // if (data.style.strokeColor) {
      //     label.strokeColor = new Color(data.style.strokeColor);
      // }
      if (data.style.bold !== undefined) {
        label.isBold = data.style.bold;
      }
      if (data.style.italic !== undefined) {
        label.isItalic = data.style.italic;
      }
    }
  }


  /**
   * 根据当前语言更新精灵帧
   * @param sprite 
   */
  static updateSpriteFrame(sprite:Sprite){
    const nameSpriteFrame = sprite.spriteFrame.name
    const nameDefault = nameSpriteFrame.split('-')[0];
    resources.load("common/group_" + nameDefault + "/" + nameDefault + "-" + this.curLanguage + "/spriteFrame", SpriteFrame, (err, spriteFrame:SpriteFrame) => {
      if(spriteFrame){
        sprite.spriteFrame = spriteFrame
      }

    });
    
  }

  /**
   * 设置当前语言
   * @param {string} languageName - 语言代码
   */
  static setLocalize(languageName: string): void {
    if (this.languages[languageName]) {
      this.curLanguage = languageName;
      this.curLanguageName = this.languages[languageName].name;
    }
  }

  /**
   * 检测浏览器语言
   * @private
   */
  private static detectBrowserLanguage(): void {
    const lang = navigator.language.toLowerCase();
    if (this.languages[lang]) {
      this.setLocalize(lang);
    } else {
      this.setLocalize(this._defaultLanguage);
    }
  }

  /**
   * 初始化语言配置
   */
  static initLanguageConfig(): void {
    const languageConfig = resources.get("config/languages", JsonAsset);
    const config = this.parseLanguageConfig(languageConfig);
    if (config) {
      this.initialize(config);
    }
  }
}
